// sgu325
// 题意：
// 给定一个长为n(<=1000000)的由大写字母组成的串，现在你可以随意交换相邻两个
// 字母，问最少交换几次能得到回文串，如果不能，输出-1。
//
// 题解：
// 首先，把无解的情况处理了。其次，怎么得到回文串呢？贪心就行。怎么贪心？
// 我们从左往右扫描串，每次只需要将和当前位置的字符相同的离他最远的字符调整
// 到对应位置的去就行。
// 怎么证明呢？反证法就行，假设前k个位置(和对应后i个位置)已经是回文的，那么
// 对于当前这个位置k+1，如果采用这个字符，最小的代价就是把最远的相同的字符
// 调整过去，如果不采用，那么你可以比划一下，肯定比采用所花的费用高。
//
// 有了这个贪心的基础，我们只需要从左往右扫描字符串，维护当前是第k个回文位置，
// 然后用预处理好的每个字符对应的位置序列得到相同字符的最后一个位置last，
// 然后还要用树状数组维护last之前被移动的字符个数tmp，这样对于当前字符要交换的
// 次数就是n-k-1 - last + tmp(下标是[0, n))。
//
// 最后单独算奇数时候中间字符移动次数就行。
//
// run: $exec < input
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>

int const maxm = 26;
int const maxn = 1000007;
int count[maxm + 4];
int tree[maxn];
bool vis[maxn];
int n, odd = -1, odd_pos = -1;
std::string s;
std::vector<int> all[maxm];

int lowbit(int x) { return x & -x; }

void update(int id, int d)
{
	for (; id <= n; id += lowbit(id)) tree[id] += d;
}

int sum(int id)
{
	int ret = 0;
	for (; id > 0; id -= lowbit(id)) ret += tree[id];
	return ret;
}

int main()
{
	std::ios::sync_with_stdio(false);
	std::cin >> s;
	n = s.size();
	for (int i = 0; i < n; i++) {
		count[s[i] - 'A']++;
		all[s[i] - 'A'].push_back(i);
	}
	for (int i = 0; i < maxm; i++)
		if (count[i] & 1) {
			if (odd != -1) { std::cout << "-1\n"; return 0; }
			odd = i;
		}
	long long ans = 0;
	int k = 0;
	for (int i = 0; i < n; i++) {
		if (vis[i]) continue;
		int id = s[i] - 'A';
		if (id == odd && count[id] == 1) {
			odd_pos = i;
			continue;
		}
		int last = all[id][all[id].size() - 1];
		int target = n - 1 - k++;
		int tmp = sum(last + 1);
		ans += target - last + tmp;
		all[id].pop_back();
		update(last + 1, 1);
		vis[last] = true;
		count[id] -= 2;
	}
	if (odd != -1) ans += n/2 - odd_pos + sum(odd_pos + 1);
	std::cout << ans << '\n';
}

